home *** CD-ROM | disk | FTP | other *** search
/ PC World 2008 March / PCWorld_2008-03_cd.bin / v cisle / mobiDVD / MobiDVD-1.0.0.6.exe / xulrunner / components / FeedProcessor.js < prev    next >
Text File  |  2007-06-30  |  62KB  |  1,816 lines
  1. /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
  2. /* ***** BEGIN LICENSE BLOCK *****
  3.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  4.  *
  5.  * The contents of this file are subject to the Mozilla Public License Version
  6.  * 1.1 (the "License"); you may not use this file except in compliance with
  7.  * the License. You may obtain a copy of the License at
  8.  * http://www.mozilla.org/MPL/
  9.  *
  10.  * Software distributed under the License is distributed on an "AS IS" basis,
  11.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12.  * for the specific language governing rights and limitations under the
  13.  * License.
  14.  *
  15.  * The Original Code is mozilla.org code.
  16.  *
  17.  * The Initial Developer of the Original Code is Robert Sayre.
  18.  * Portions created by the Initial Developer are Copyright (C) 2006
  19.  * the Initial Developer. All Rights Reserved.
  20.  *
  21.  * Contributor(s):
  22.  *   Ben Goodger <beng@google.com>
  23.  *   Myk Melez <myk@mozilla.org>
  24.  *   Michael Ventnor <m.ventnor@gmail.com>
  25.  *
  26.  * Alternatively, the contents of this file may be used under the terms of
  27.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  28.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29.  * in which case the provisions of the GPL or the LGPL are applicable instead
  30.  * of those above. If you wish to allow use of your version of this file only
  31.  * under the terms of either the GPL or the LGPL, and not to allow others to
  32.  * use your version of this file under the terms of the MPL, indicate your
  33.  * decision by deleting the provisions above and replace them with the notice
  34.  * and other provisions required by the GPL or the LGPL. If you do not delete
  35.  * the provisions above, a recipient may use your version of this file under
  36.  * the terms of any one of the MPL, the GPL or the LGPL.
  37.  *
  38.  * ***** END LICENSE BLOCK ***** */
  39.  
  40. function LOG(str) {
  41.   dump("*** " + str + "\n");
  42. }
  43.  
  44. const Ci = Components.interfaces;
  45. const Cc = Components.classes;
  46. const Cr = Components.results;
  47. Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
  48.  
  49. const FP_CONTRACTID = "@mozilla.org/feed-processor;1";
  50. const FP_CLASSID = Components.ID("{26acb1f0-28fc-43bc-867a-a46aabc85dd4}");
  51. const FP_CLASSNAME = "Feed Processor";
  52. const FR_CONTRACTID = "@mozilla.org/feed-result;1";
  53. const FR_CLASSID = Components.ID("{072a5c3d-30c6-4f07-b87f-9f63d51403f2}");
  54. const FR_CLASSNAME = "Feed Result";
  55. const FEED_CONTRACTID = "@mozilla.org/feed;1";
  56. const FEED_CLASSID = Components.ID("{5d0cfa97-69dd-4e5e-ac84-f253162e8f9a}");
  57. const FEED_CLASSNAME = "Feed";
  58. const ENTRY_CONTRACTID = "@mozilla.org/feed-entry;1";
  59. const ENTRY_CLASSID = Components.ID("{8e4444ff-8e99-4bdd-aa7f-fb3c1c77319f}");
  60. const ENTRY_CLASSNAME = "Feed Entry";
  61. const TEXTCONSTRUCT_CONTRACTID = "@mozilla.org/feed-textconstruct;1";
  62. const TEXTCONSTRUCT_CLASSID =
  63.   Components.ID("{b992ddcd-3899-4320-9909-924b3e72c922}");
  64. const TEXTCONSTRUCT_CLASSNAME = "Feed Text Construct";
  65. const GENERATOR_CONTRACTID = "@mozilla.org/feed-generator;1";
  66. const GENERATOR_CLASSID =
  67.   Components.ID("{414af362-9ad8-4296-898e-62247f25a20e}");
  68. const GENERATOR_CLASSNAME = "Feed Generator";
  69. const PERSON_CONTRACTID = "@mozilla.org/feed-person;1";
  70. const PERSON_CLASSID = Components.ID("{95c963b7-20b2-11db-92f6-001422106990}");
  71. const PERSON_CLASSNAME = "Feed Person";
  72.  
  73. const IO_CONTRACTID = "@mozilla.org/network/io-service;1"
  74. const BAG_CONTRACTID = "@mozilla.org/hash-property-bag;1"
  75. const ARRAY_CONTRACTID = "@mozilla.org/array;1";
  76. const SAX_CONTRACTID = "@mozilla.org/saxparser/xmlreader;1";
  77. const UNESCAPE_CONTRACTID = "@mozilla.org/feed-unescapehtml;1";
  78.  
  79.  
  80. var gIoService = Cc[IO_CONTRACTID].getService(Ci.nsIIOService);
  81. var gUnescapeHTML = Cc[UNESCAPE_CONTRACTID].
  82.                     getService(Ci.nsIScriptableUnescapeHTML);
  83.  
  84. const XMLNS = "http://www.w3.org/XML/1998/namespace";
  85. const RSS090NS = "http://my.netscape.com/rdf/simple/0.9/";
  86. const WAIROLE_NS = "http://www.w3.org/2005/01/wai-rdf/GUIRoleTaxonomy#";
  87.  
  88. /***** Some general utils *****/
  89. function strToURI(link, base) {
  90.   var base = base || null;
  91.   try {
  92.     return gIoService.newURI(link, null, base);
  93.   }
  94.   catch(e) {
  95.     return null;
  96.   }
  97. }
  98.  
  99. function isArray(a) {
  100.   return isObject(a) && a.constructor == Array;
  101. }
  102.  
  103. function isObject(a) {
  104.   return (a && typeof a == "object") || isFunction(a);
  105. }
  106.  
  107. function isFunction(a) {
  108.   return typeof a == "function";
  109. }
  110.  
  111. function isIID(a, iid) {
  112.   var rv = false;
  113.   try {
  114.     a.QueryInterface(iid);
  115.     rv = true;
  116.   }
  117.   catch(e) {
  118.   }
  119.   return rv;
  120. }
  121.  
  122. function isIArray(a) {
  123.   return isIID(a, Ci.nsIArray);
  124. }
  125.  
  126. function isIFeedContainer(a) {
  127.   return isIID(a, Ci.nsIFeedContainer);
  128. }
  129.  
  130. function stripTags(someHTML) {
  131.   return someHTML.replace(/<[^>]+>/g,"");
  132. }
  133.  
  134. /**
  135.  * Searches through an array of links and returns a JS array 
  136.  * of matching property bags.
  137.  */
  138. const IANA_URI = "http://www.iana.org/assignments/relation/";
  139. function findAtomLinks(rel, links) {
  140.   var rvLinks = [];
  141.   for (var i = 0; i < links.length; ++i) {
  142.     var linkElement = links.queryElementAt(i, Ci.nsIPropertyBag2);
  143.     // atom:link MUST have @href
  144.     if (bagHasKey(linkElement, "href")) {
  145.       var relAttribute = null;
  146.       if (bagHasKey(linkElement, "rel"))
  147.         relAttribute = linkElement.getPropertyAsAString("rel")
  148.       if ((!relAttribute && rel == "alternate") || relAttribute == rel) {
  149.         rvLinks.push(linkElement);
  150.         continue;
  151.       }
  152.       // catch relations specified by IANA URI 
  153.       if (relAttribute == IANA_URI + rel) {
  154.         rvLinks.push(linkElement);
  155.       }
  156.     }
  157.   }
  158.   return rvLinks;
  159. }
  160.  
  161. function xmlEscape(s) {
  162.   s = s.replace(/&/g, "&");
  163.   s = s.replace(/>/g, ">");
  164.   s = s.replace(/</g, "<");
  165.   s = s.replace(/"/g, """);
  166.   s = s.replace(/'/g, "'");
  167.   return s;
  168. }
  169.  
  170. function arrayContains(array, element) {
  171.   for (var i = 0; i < array.length; ++i) {
  172.     if (array[i] == element) {
  173.       return true;
  174.     }
  175.   }
  176.   return false;
  177. }
  178.  
  179. // XXX add hasKey to nsIPropertyBag
  180. function bagHasKey(bag, key) {
  181.   try {
  182.     bag.getProperty(key);
  183.     return true;
  184.   }
  185.   catch (e) {
  186.     return false;
  187.   }
  188. }
  189.  
  190. function makePropGetter(key) {
  191.   return function FeedPropGetter(bag) {
  192.     try {
  193.       return value = bag.getProperty(key);
  194.     }
  195.     catch(e) {
  196.     }
  197.     return null;
  198.   }
  199. }
  200.  
  201.  
  202.  
  203. /**
  204.  * XXX Thunderbird's W3C-DTF function
  205.  *
  206.  * Converts a W3C-DTF (subset of ISO 8601) date string to an IETF date
  207.  * string.  W3C-DTF is described in this note:
  208.  * http://www.w3.org/TR/NOTE-datetime IETF is obtained via the Date
  209.  * object's toUTCString() method.  The object's toString() method is
  210.  * insufficient because it spells out timezones on Win32
  211.  * (f.e. "Pacific Standard Time" instead of "PST"), which Mail doesn't
  212.  * grok.  For info, see
  213.  * http://lxr.mozilla.org/mozilla/source/js/src/jsdate.c#1526.
  214.  */
  215. const HOURS_TO_MINUTES = 60;
  216. const MINUTES_TO_SECONDS = 60;
  217. const SECONDS_TO_MILLISECONDS = 1000;
  218. const MINUTES_TO_MILLISECONDS = MINUTES_TO_SECONDS * SECONDS_TO_MILLISECONDS;
  219. const HOURS_TO_MILLISECONDS = HOURS_TO_MINUTES * MINUTES_TO_MILLISECONDS;
  220. function W3CToIETFDate(dateString) {
  221.  
  222.   var parts = dateString.match(/(\d\d\d\d)(-(\d\d))?(-(\d\d))?(T(\d\d):(\d\d)(:(\d\d)(\.(\d+))?)?(Z|([+-])(\d\d):(\d\d))?)?/);
  223.  
  224.   // Here's an example of a W3C-DTF date string and what .match returns for it.
  225.   // 
  226.   // date: 2003-05-30T11:18:50.345-08:00
  227.   // date.match returns array values:
  228.   //
  229.   //   0: 2003-05-30T11:18:50-08:00,
  230.   //   1: 2003,
  231.   //   2: -05,
  232.   //   3: 05,
  233.   //   4: -30,
  234.   //   5: 30,
  235.   //   6: T11:18:50-08:00,
  236.   //   7: 11,
  237.   //   8: 18,
  238.   //   9: :50,
  239.   //   10: 50,
  240.   //   11: .345,
  241.   //   12: 345,
  242.   //   13: -08:00,
  243.   //   14: -,
  244.   //   15: 08,
  245.   //   16: 00
  246.  
  247.   // Create a Date object from the date parts.  Note that the Date
  248.   // object apparently can't deal with empty string parameters in lieu
  249.   // of numbers, so optional values (like hours, minutes, seconds, and
  250.   // milliseconds) must be forced to be numbers.
  251.   var date = new Date(parts[1], parts[3] - 1, parts[5], parts[7] || 0,
  252.                       parts[8] || 0, parts[10] || 0, parts[12] || 0);
  253.  
  254.   // We now have a value that the Date object thinks is in the local
  255.   // timezone but which actually represents the date/time in the
  256.   // remote timezone (f.e. the value was "10:00 EST", and we have
  257.   // converted it to "10:00 PST" instead of "07:00 PST").  We need to
  258.   // correct that.  To do so, we're going to add the offset between
  259.   // the remote timezone and UTC (to convert the value to UTC), then
  260.   // add the offset between UTC and the local timezone //(to convert
  261.   // the value to the local timezone).
  262.  
  263.   // Ironically, W3C-DTF gives us the offset between UTC and the
  264.   // remote timezone rather than the other way around, while the
  265.   // getTimezoneOffset() method of a Date object gives us the offset
  266.   // between the local timezone and UTC rather than the other way
  267.   // around.  Both of these are the additive inverse (i.e. -x for x)
  268.   // of what we want, so we have to invert them to use them by
  269.   // multipying by -1 (f.e. if "the offset between UTC and the remote
  270.   // timezone" is -5 hours, then "the offset between the remote
  271.   // timezone and UTC" is -5*-1 = 5 hours).
  272.  
  273.   // Note that if the timezone portion of the date/time string is
  274.   // absent (which violates W3C-DTF, although ISO 8601 allows it), we
  275.   // assume the value to be in UTC.
  276.  
  277.   // The offset between the remote timezone and UTC in milliseconds.
  278.   var remoteToUTCOffset = 0;
  279.   if (parts[13] && parts[13] != "Z") {
  280.     var direction = (parts[14] == "+" ? 1 : -1);
  281.     if (parts[15])
  282.       remoteToUTCOffset += direction * parts[15] * HOURS_TO_MILLISECONDS;
  283.     if (parts[16])
  284.       remoteToUTCOffset += direction * parts[16] * MINUTES_TO_MILLISECONDS;
  285.   }
  286.   remoteToUTCOffset = remoteToUTCOffset * -1; // invert it
  287.  
  288.   // The offset between UTC and the local timezone in milliseconds.
  289.   var UTCToLocalOffset = date.getTimezoneOffset() * MINUTES_TO_MILLISECONDS;
  290.   UTCToLocalOffset = UTCToLocalOffset * -1; // invert it
  291.   date.setTime(date.getTime() + remoteToUTCOffset + UTCToLocalOffset);
  292.  
  293.   return date.toUTCString();
  294. }
  295.  
  296. const RDF_NS = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
  297. // namespace map
  298. var gNamespaces = {
  299.   "http://webns.net/mvcb/":"admin",
  300.   "http://backend.userland.com/rss":"",
  301.   "http://blogs.law.harvard.edu/tech/rss":"",
  302.   "http://www.w3.org/2005/Atom":"atom",
  303.   "http://purl.org/atom/ns#":"atom03",
  304.   "http://purl.org/rss/1.0/modules/content/":"content",
  305.   "http://purl.org/dc/elements/1.1/":"dc",
  306.   "http://purl.org/dc/terms/":"dcterms",
  307.   "http://www.w3.org/1999/02/22-rdf-syntax-ns#":"rdf",
  308.   "http://purl.org/rss/1.0/":"rss1",
  309.   "http://my.netscape.com/rdf/simple/0.9/":"rss1",
  310.   "http://wellformedweb.org/CommentAPI/":"wfw",                              
  311.   "http://purl.org/rss/1.0/modules/wiki/":"wiki", 
  312.   "http://www.w3.org/XML/1998/namespace":"xml"
  313. }
  314.  
  315. // We allow a very small set of namespaces in XHTML content,
  316. // for attributes only
  317. var gAllowedXHTMLNamespaces = {
  318.   "http://www.w3.org/XML/1998/namespace":"xml",
  319.   "http://www.w3.org/TR/xhtml2":"xhtml2",
  320.   "http://www.w3.org/2005/07/aaa":"aaa",
  321.   // if someone ns qualifies XHTML, we have to prefix it to avoid an
  322.   // attribute collision.
  323.   "http://www.w3.org/1999/xhtml":"xhtml"
  324. }
  325.  
  326. function FeedResult() {}
  327. FeedResult.prototype = {
  328.   bozo: false,
  329.   doc: null,
  330.   version: null,
  331.   headers: null,
  332.   uri: null,
  333.   stylesheet: null,
  334.  
  335.   registerExtensionPrefix: function FR_registerExtensionPrefix(ns, prefix) {
  336.     throw Cr.NS_ERROR_NOT_IMPLEMENTED;
  337.   },
  338.  
  339.   // XPCOM stuff
  340.   classDescription: FR_CLASSNAME,
  341.   classID: FR_CLASSID,
  342.   contractID: FR_CONTRACTID,
  343.   QueryInterface: XPCOMUtils.generateQI([Ci.nsIFeedResult])
  344. }  
  345.  
  346. function Feed() {
  347.   this.subtitle = null;
  348.   this.title = null;
  349.   this.items = Cc[ARRAY_CONTRACTID].createInstance(Ci.nsIMutableArray);
  350.   this.link = null;
  351.   this.id = null;
  352.   this.generator = null;
  353.   this.authors = Cc[ARRAY_CONTRACTID].createInstance(Ci.nsIMutableArray);
  354.   this.contributors = Cc[ARRAY_CONTRACTID].createInstance(Ci.nsIMutableArray);
  355.   this.baseURI = null;
  356. }
  357.  
  358. Feed.prototype = {
  359.   searchLists: {
  360.     title: ["title", "rss1:title", "atom03:title", "atom:title"],
  361.     subtitle: ["description","dc:description","rss1:description",
  362.                "atom03:tagline","atom:subtitle"],
  363.     items: ["items","atom03_entries","entries"],
  364.     id: ["atom:id","rdf:about"],
  365.     generator: ["generator"],
  366.     authors : ["authors"],
  367.     contributors: ["contributors"],
  368.     title: ["title","rss1:title", "atom03:title","atom:title"],
  369.     link:  [["link",strToURI],["rss1:link",strToURI]],
  370.     categories: ["categories", "dc:subject"],
  371.     rights: ["atom03:rights","atom:rights"],
  372.     cloud: ["cloud"],
  373.     image: ["image", "rss1:image", "atom:logo"],
  374.     textInput: ["textInput", "rss1:textinput"],
  375.     skipDays: ["skipDays"],
  376.     skipHours: ["skipHours"],
  377.     updated: ["pubDate", "lastBuildDate", "atom03:modified", "dc:date",
  378.               "dcterms:modified", "atom:updated"]
  379.   },
  380.  
  381.   normalize: function Feed_normalize() {
  382.     fieldsToObj(this, this.searchLists);
  383.     if (this.skipDays)
  384.       this.skipDays = this.skipDays.getProperty("days");
  385.     if (this.skipHours)
  386.       this.skipHours = this.skipHours.getProperty("hours");
  387.  
  388.     if (this.updated)
  389.       this.updated = dateParse(this.updated);
  390.  
  391.     // Assign Atom link if needed
  392.     if (bagHasKey(this.fields, "links"))
  393.       this._atomLinksToURI();
  394.  
  395.     // Resolve relative image links
  396.     if (this.image && bagHasKey(this.image, "url"))
  397.       this._resolveImageLink();
  398.  
  399.     this._resetBagMembersToRawText([this.searchLists.subtitle, 
  400.                                     this.searchLists.title]);
  401.   },
  402.  
  403.   _atomLinksToURI: function Feed_linkToURI() {
  404.     var links = this.fields.getPropertyAsInterface("links", Ci.nsIArray);
  405.     var alternates = findAtomLinks("alternate", links);
  406.     if (alternates.length > 0) {
  407.       var href = alternates[0].getPropertyAsAString("href");
  408.       var base;
  409.       if (bagHasKey(alternates[0], "xml:base"))
  410.         base = alternates[0].getPropertyAsAString("xml:base");
  411.       this.link = this._resolveURI(href, base);
  412.     }
  413.   },
  414.  
  415.   _resolveImageLink: function Feed_resolveImageLink() {
  416.     var base;
  417.     if (bagHasKey(this.image, "xml:base"))
  418.       base = this.image.getPropertyAsAString("xml:base");
  419.     var url = this._resolveURI(this.image.getPropertyAsAString("url"), base);
  420.     if (url)
  421.       this.image.setPropertyAsAString("url", url.spec);
  422.   },
  423.  
  424.   _resolveURI: function Feed_resolveURI(linkSpec, baseSpec) {
  425.     var uri = null;
  426.     try {
  427.       var base = baseSpec ? strToURI(baseSpec, this.baseURI) : this.baseURI;
  428.       uri = strToURI(linkSpec, base);
  429.     }
  430.     catch(e) {
  431.       LOG(e);
  432.     }
  433.  
  434.     return uri;
  435.   },
  436.  
  437.   // reset the bag to raw contents, not text constructs
  438.   _resetBagMembersToRawText: function Feed_resetBagMembers(fieldLists) {
  439.     for (var i=0; i<fieldLists.length; i++) {      
  440.       for (var j=0; j<fieldLists[i].length; j++) {
  441.         if (bagHasKey(this.fields, fieldLists[i][j])) {
  442.           var textConstruct = this.fields.getProperty(fieldLists[i][j]);
  443.           this.fields.setPropertyAsAString(fieldLists[i][j],
  444.                                            textConstruct.text);
  445.         }
  446.       }
  447.     }
  448.   },
  449.   
  450.   // XPCOM stuff
  451.   classDescription: FEED_CLASSNAME,
  452.   classID: FEED_CLASSID,
  453.   contractID: FEED_CONTRACTID,
  454.   QueryInterface: XPCOMUtils.generateQI([Ci.nsIFeed, Ci.nsIFeedContainer])
  455. }
  456.  
  457. function Entry() {
  458.   this.summary = null;
  459.   this.content = null;
  460.   this.title = null;
  461.   this.fields = Cc["@mozilla.org/hash-property-bag;1"].
  462.     createInstance(Ci.nsIWritablePropertyBag2);
  463.   this.link = null;
  464.   this.id = null;
  465.   this.baseURI = null;
  466.   this.updated = null;
  467.   this.published = null;
  468.   this.authors = Cc[ARRAY_CONTRACTID].createInstance(Ci.nsIMutableArray);
  469.   this.contributors = Cc[ARRAY_CONTRACTID].createInstance(Ci.nsIMutableArray);
  470. }
  471.   
  472. Entry.prototype = {
  473.   fields: null,
  474.   enclosures: null,
  475.   mediaContent: null,
  476.   
  477.   searchLists: {
  478.     title: ["title", "rss1:title", "atom03:title", "atom:title"],
  479.     link: [["link",strToURI],["rss1:link",strToURI]],
  480.     id: [["guid", makePropGetter("guid")], "rdf:about",
  481.          "atom03:id", "atom:id"],
  482.     authors : ["authors"],
  483.     contributors: ["contributors"],
  484.     summary: ["description", "rss1:description", "dc:description",
  485.               "atom03:summary", "atom:summary"],
  486.     content: ["content:encoded","atom03:content","atom:content"],
  487.     rights: ["atom03:rights","atom:rights"],
  488.     published: ["atom03:issued", "dcterms:issued", "atom:published"],
  489.     updated: ["pubDate", "atom03:modified", "dc:date", "dcterms:modified",
  490.               "atom:updated"]
  491.   },
  492.   
  493.   normalize: function Entry_normalize() {
  494.     fieldsToObj(this, this.searchLists);
  495.  
  496.     // Assign Atom link if needed
  497.     if (bagHasKey(this.fields, "links"))
  498.       this._atomLinksToURI();
  499.  
  500.     // The link might be a guid w/ permalink=true
  501.     if (!this.link && bagHasKey(this.fields, "guid")) {
  502.       var guid = this.fields.getProperty("guid");
  503.       var isPermaLink = true;
  504.       
  505.       if (bagHasKey(guid, "isPermaLink"))
  506.         isPermaLink = guid.getProperty("isPermaLink").toLowerCase() != "false";
  507.       
  508.       if (guid && isPermaLink)
  509.         this.link = strToURI(guid.getProperty("guid"));
  510.     }
  511.  
  512.     if (this.updated)
  513.       this.updated = dateParse(this.updated);
  514.     if (this.published)
  515.       this.published = dateParse(this.published);
  516.  
  517.     this._resetBagMembersToRawText([this.searchLists.content, 
  518.                                     this.searchLists.summary, 
  519.                                     this.searchLists.title]);
  520.   },
  521.  
  522.   // XPCOM stuff
  523.   classDescription: ENTRY_CLASSNAME,
  524.   classID: ENTRY_CLASSID,
  525.   contractID: ENTRY_CONTRACTID,
  526.   QueryInterface: XPCOMUtils.generateQI(
  527.     [Ci.nsIFeedEntry, Ci.nsIFeedContainer]
  528.   )
  529. }
  530.  
  531. Entry.prototype._atomLinksToURI = Feed.prototype._atomLinksToURI;
  532. Entry.prototype._resolveURI = Feed.prototype._resolveURI;
  533. Entry.prototype._resetBagMembersToRawText = 
  534.    Feed.prototype._resetBagMembersToRawText;
  535.  
  536. // TextConstruct represents and element that could contain (X)HTML
  537. function TextConstruct() {
  538.   this.lang = null;
  539.   this.base = null;
  540.   this.type = "text";
  541.   this.text = null;
  542. }
  543.  
  544. TextConstruct.prototype = {
  545.   plainText: function TC_plainText() {
  546.     if (this.type != "text") {
  547.       return gUnescapeHTML.unescape(stripTags(this.text));
  548.     }
  549.     return this.text;
  550.   },
  551.  
  552.   createDocumentFragment: function TC_createDocumentFragment(element) {
  553.     if (this.type == "text") {
  554.       var doc = element.ownerDocument;
  555.       var docFragment = doc.createDocumentFragment();
  556.       var node = doc.createTextNode(this.text);
  557.       docFragment.appendChild(node);
  558.       return docFragment;
  559.     }
  560.     var isXML;
  561.     if (this.type == "xhtml")
  562.       isXML = true
  563.     else if (this.type == "html")
  564.       isXML = false;
  565.     else
  566.       return null;
  567.  
  568.     return gUnescapeHTML.parseFragment(this.text, isXML, this.base, element);
  569.   },
  570.  
  571.   // XPCOM stuff
  572.   classDescription: TEXTCONSTRUCT_CLASSNAME,
  573.   classID: TEXTCONSTRUCT_CLASSID,
  574.   contractID: TEXTCONSTRUCT_CONTRACTID,
  575.   QueryInterface: XPCOMUtils.generateQI([Ci.nsIFeedTextConstruct])
  576. }
  577.  
  578. // Generator represents the software that produced the feed
  579. function Generator() {
  580.   this.lang = null;
  581.   this.agent = null;
  582.   this.version = null;
  583.   this.uri = null;
  584.  
  585.   // nsIFeedElementBase
  586.   this._attributes = null;
  587.   this.baseURI = null;
  588. }
  589.  
  590. Generator.prototype = {
  591.  
  592.   get attributes() {
  593.     return this._attributes;
  594.   },
  595.  
  596.   set attributes(value) {
  597.     this._attributes = value;
  598.     this.version = this._attributes.getValueFromName("","version");
  599.     var uriAttribute = this._attributes.getValueFromName("","uri") ||
  600.                        this._attributes.getValueFromName("","url");
  601.     this.uri = strToURI(uriAttribute, this.baseURI);
  602.  
  603.     // RSS1
  604.     uriAttribute = this._attributes.getValueFromName(RDF_NS,"resource");
  605.     if (uriAttribute) {
  606.       this.agent = uriAttribute;
  607.       this.uri = strToURI(uriAttribute, this.baseURI);
  608.     }
  609.   },
  610.  
  611.   // XPCOM stuff
  612.   classDescription: GENERATOR_CLASSNAME,
  613.   classID: GENERATOR_CLASSID,
  614.   contractID: GENERATOR_CONTRACTID,
  615.   QueryInterface: XPCOMUtils.generateQI(
  616.     [Ci.nsIFeedGenerator, Ci.nsIFeedElementBase]
  617.   )
  618. }
  619.  
  620. function Person() {
  621.   this.name = null;
  622.   this.uri = null;
  623.   this.email = null;
  624.  
  625.   // nsIFeedElementBase
  626.   this.attributes = null;
  627.   this.baseURI = null;
  628. }
  629.  
  630. Person.prototype = {
  631.   // XPCOM stuff
  632.   classDescription: PERSON_CLASSNAME,
  633.   classID: PERSON_CLASSID,
  634.   contractID: PERSON_CONTRACTID,
  635.   QueryInterface: XPCOMUtils.generateQI(
  636.     [Ci.nsIFeedPerson, Ci.nsIFeedElementBase]
  637.   )
  638. }
  639.  
  640. /** 
  641.  * Map a list of fields into properties on a container.
  642.  *
  643.  * @param container An nsIFeedContainer
  644.  * @param fields A list of fields to search for. List members can
  645.  *               be a list, in which case the second member is 
  646.  *               transformation function (like parseInt).
  647.  */
  648. function fieldsToObj(container, fields) {
  649.   var props,prop,field,searchList;
  650.   for (var key in fields) {
  651.     searchList = fields[key];
  652.     for (var i=0; i < searchList.length; ++i) {
  653.       props = searchList[i];
  654.       prop = null;
  655.       field = isArray(props) ? props[0] : props;
  656.       try {
  657.         prop = container.fields.getProperty(field);
  658.       } 
  659.       catch(e) { 
  660.       }
  661.       if (prop) {
  662.         prop = isArray(props) ? props[1](prop) : prop;
  663.         container[key] = prop;
  664.       }
  665.     }
  666.   }
  667. }
  668.  
  669. /**
  670.  * Lower cases an element's localName property
  671.  * @param   element A DOM element.
  672.  *
  673.  * @returns The lower case localName property of the specified element
  674.  */
  675. function LC(element) {
  676.   return element.localName.toLowerCase();
  677. }
  678.  
  679. // TODO move these post-processor functions
  680. // create a generator element
  681. function atomGenerator(s, generator) {
  682.   generator.QueryInterface(Ci.nsIFeedGenerator);
  683.   generator.agent = trimString(s);
  684.   return generator;
  685. }
  686.  
  687. // post-process atom:logo to create an RSS2-like structure
  688. function atomLogo(s, logo) {
  689.   logo.setPropertyAsAString("url", trimString(s));
  690. }
  691.  
  692. // post-process an RSS category, map it to the Atom fields.
  693. function rssCatTerm(s, cat) {
  694.   // add slash handling?
  695.   cat.setPropertyAsAString("term", trimString(s));
  696.   return cat;
  697. } 
  698.  
  699. // post-process a GUID 
  700. function rssGuid(s, guid) {
  701.   guid.setPropertyAsAString("guid", trimString(s));
  702.   return guid;
  703. }
  704.  
  705. // post-process an RSS author element
  706. //
  707. // It can contain a field like this:
  708. // 
  709. //  <author>lawyer@boyer.net (Lawyer Boyer)</author>
  710. //
  711. // or, delightfully, a field like this:
  712. //
  713. //  <dc:creator>Simon St.Laurent (mailto:simonstl@simonstl.com)</dc:creator>
  714. //
  715. // We want to split this up and assign it to corresponding Atom
  716. // fields.
  717. //
  718. function rssAuthor(s,author) {
  719.   author.QueryInterface(Ci.nsIFeedPerson);
  720.   // check for RSS2 string format
  721.   var chars = trimString(s);
  722.   var matches = chars.match(/(.*)\((.*)\)/);
  723.   var emailCheck = 
  724.     /^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/;
  725.   if (matches) {
  726.     var match1 = trimString(matches[1]);
  727.     var match2 = trimString(matches[2]);
  728.     if (match2.indexOf("mailto:") == 0)
  729.       match2 = match2.substring(7);
  730.     if (emailCheck.test(match1)) {
  731.       author.email = match1;
  732.       author.name = match2;
  733.     }
  734.     else if (emailCheck.test(match2)) {
  735.       author.email = match2;
  736.       author.name = match1;
  737.     }
  738.     else {
  739.       // put it back together
  740.       author.name = match1 + " (" + match2 + ")";
  741.     }
  742.   }
  743.   else {
  744.     author.name = chars;
  745.     if (chars.indexOf('@'))
  746.       author.email = chars;
  747.   }
  748.   return author;
  749. }
  750.  
  751. //
  752. // skipHours and skipDays map to arrays, so we need to change the
  753. // string to an nsISupports in order to stick it in there.
  754. //
  755. function rssArrayElement(s) {
  756.   var str = Cc["@mozilla.org/supports-string;1"].
  757.               createInstance(Ci.nsISupportsString);
  758.   str.data = s;
  759.   str.QueryInterface(Ci.nsISupportsString);
  760.   return str;
  761. }
  762.  
  763. /***** Some feed utils from TBird *****/
  764.  
  765. /**
  766.  * Tests a RFC822 date against a regex.
  767.  * @param aDateStr A string to test as an RFC822 date.
  768.  *
  769.  * @returns A boolean indicating whether the string is a valid RFC822 date.
  770.  */
  771. function isValidRFC822Date(aDateStr) {
  772.   var regex = new RegExp(RFC822_RE);
  773.   return regex.test(aDateStr);
  774. }
  775.  
  776. /**
  777.  * Removes leading and trailing whitespace from a string.
  778.  * @param s The string to trim.
  779.  *
  780.  * @returns A new string with whitespace stripped.
  781.  */
  782. function trimString(s) {
  783.   return(s.replace(/^\s+/, "").replace(/\s+$/, ""));
  784. }
  785.  
  786. // Regular expression matching RFC822 dates 
  787. const RFC822_RE = "^((Mon|Tue|Wed|Thu|Fri|Sat|Sun)([a-z]+)?,? *)?\\d\\d?"
  788. + " +(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)([a-z]+)?"
  789. + " +\\d\\d(\\d\\d)? +\\d?\\d:\\d\\d(:\\d\\d)?"
  790. + " +([+-]?\\d\\d\\d\\d|GMT|UT[C]?|(E|C|M|P)(ST|DT)|[A-IK-Z])$";
  791.  
  792. /**
  793.  * XXX -- need to decide what this should return. 
  794.  * XXX -- Is there a Date class usable from C++?
  795.  *
  796.  * Tries tries parsing various date formats.
  797.  * @param dateString
  798.  *        A string that is supposedly an RFC822 or RFC3339 date.
  799.  * @returns A Date.toString XXX--fixme
  800.  */
  801. function dateParse(dateString) {
  802.   var date = trimString(dateString);
  803.  
  804.   if (date.search(/^\d\d\d\d/) != -1) //Could be a ISO8601/W3C date
  805.     return W3CToIETFDate(dateString);
  806.  
  807.   if (isValidRFC822Date(date))
  808.     return date; 
  809.   
  810.   if (!isNaN(parseInt(date, 10))) { 
  811.     //It's an integer, so maybe it's a timestamp
  812.     var d = new Date(parseInt(date, 10) * 1000);
  813.     var now = new Date();
  814.     var yeardiff = now.getFullYear() - d.getFullYear();
  815.     if ((yeardiff >= 0) && (yeardiff < 3)) {
  816.       // it's quite likely the correct date. 3 years is an arbitrary cutoff,
  817.       // but this is an invalid date format, and there's no way to verify
  818.       // its correctness.
  819.       return d.toString();
  820.     }
  821.   }
  822.   // Can't help.
  823.   return null;
  824. } 
  825.  
  826.  
  827. const XHTML_NS = "http://www.w3.org/1999/xhtml";
  828.  
  829. // The XHTMLHandler handles inline XHTML found in things like atom:summary
  830. function XHTMLHandler(processor, isAtom, waiPrefixes) {
  831.   this._buf = "";
  832.   this._processor = processor;
  833.   this._depth = 0;
  834.   this._isAtom = isAtom;
  835.   // a stack of lists tracking in-scope namespaces
  836.   this._inScopeNS = [];
  837.   this._waiPrefixes = waiPrefixes;
  838. }
  839.  
  840. // The fidelity can be improved here, to allow handling of stuff like
  841. // SVG and MathML. XXX
  842. XHTMLHandler.prototype = {
  843.  
  844.    // look back up at the declared namespaces 
  845.    // we always use the same prefixes for our safe stuff
  846.   _isInScope: function XH__isInScope(ns) {
  847.     for (var i in this._inScopeNS) {
  848.       for (var uri in this._inScopeNS[i]) {
  849.         if (this._inScopeNS[i][uri] == ns)
  850.           return true;
  851.       }
  852.     }
  853.     return false;
  854.   },
  855.  
  856.   startDocument: function XH_startDocument() {
  857.   },
  858.   endDocument: function XH_endDocument() {
  859.   },
  860.   startElement: function XH_startElement(uri, localName, qName, attributes) {
  861.     ++this._depth;
  862.     this._inScopeNS.push([]);
  863.  
  864.     // RFC4287 requires XHTML to be wrapped in a div that is *not* part of 
  865.     // the content. This prevents people from screwing up namespaces, but
  866.     // we need to skip it here.
  867.     if (this._isAtom && this._depth == 1 && localName == "div")
  868.       return;
  869.  
  870.     // If it's an XHTML element, record it. Otherwise, it's ignored.
  871.     if (uri == XHTML_NS) {
  872.       this._buf += "<" + localName;
  873.       var uri;
  874.       for (var i=0; i < attributes.length; ++i) {
  875.         uri = attributes.getURI(i);
  876.         // XHTML attributes aren't in a namespace
  877.         if (uri == "") { 
  878.           this._buf += (" " + attributes.getLocalName(i) + "='" +
  879.                         xmlEscape(attributes.getValue(i)) + "'");
  880.         } else {
  881.           // write a small set of allowed attribute namespaces
  882.           var prefix = gAllowedXHTMLNamespaces[uri];
  883.           if (prefix != null) {
  884.             // The attribute value we'll attempt to write
  885.             var attributeValue = xmlEscape(attributes.getValue(i));
  886.  
  887.             // More QName abuse from W3C
  888.             var rolePrefix = "";
  889.             if (attributes.getLocalName(i) == "role") {
  890.               for (var aPrefix in this._waiPrefixes) {
  891.                 if (attributeValue.indexOf(aPrefix + ":") == 0) {     
  892.                   // Now, due to the terrible layer mismatch 
  893.                   // that is QNames in content, we have to see
  894.                   // if the attribute value clashes with our 
  895.                   // namespace declarations.
  896.                   var isCollision = false;
  897.                   for (var uriKey in gAllowedXHTMLNamespaces) {
  898.                     if (gAllowedXHTMLNamespaces[uriKey] == aPrefix)
  899.                       isCollision = true;
  900.                   }
  901.                   
  902.                   if (isCollision) {
  903.                     rolePrefix = aPrefix + i;
  904.                     attributeValue = 
  905.                       rolePrefix + ":" + 
  906.                       attributeValue.substring(aPrefix.length + 1);
  907.                   } else {
  908.                     rolePrefix = aPrefix;
  909.                   }
  910.  
  911.                   break;
  912.                 }
  913.               }
  914.  
  915.               if (rolePrefix)
  916.                 this._buf += (" xmlns:" + rolePrefix + 
  917.                               "='" + WAIROLE_NS + "'");
  918.             }
  919.  
  920.             // it's an allowed attribute NS.            
  921.             // write the attribute
  922.             this._buf += (" " + prefix + ":" + 
  923.                           attributes.getLocalName(i) + 
  924.                           "='" + attributeValue + "'");
  925.  
  926.             // write an xmlns declaration if necessary
  927.             if (prefix != "xml" && !this._isInScope(uri)) {
  928.               this._inScopeNS[this._inScopeNS.length - 1].push(uri);
  929.               this._buf += " xmlns:" + prefix + "='" + uri + "'";
  930.             }
  931.           }
  932.         }
  933.       }
  934.       this._buf += ">";
  935.     }
  936.   },
  937.   endElement: function XH_endElement(uri, localName, qName) {
  938.     --this._depth;
  939.     this._inScopeNS.pop();
  940.  
  941.     // We need to skip outer divs in Atom. See comment in startElement.
  942.     if (this._isAtom && this._depth == 0 && localName == "div")
  943.       return;
  944.  
  945.     // When we peek too far, go back to the main processor
  946.     if (this._depth < 0) {
  947.       this._processor.returnFromXHTMLHandler(trimString(this._buf),
  948.                                              uri, localName, qName);
  949.       return;
  950.     }
  951.     // If it's an XHTML element, record it. Otherwise, it's ignored.
  952.     if (uri == XHTML_NS) {
  953.       this._buf += "</" + localName + ">";
  954.     }
  955.   },
  956.   characters: function XH_characters(data) {
  957.     this._buf += xmlEscape(data);
  958.   },
  959.   startPrefixMapping: function XH_startPrefixMapping(prefix, uri) {
  960.     if (prefix && uri == WAIROLE_NS) 
  961.       this._waiPrefixes[prefix] = WAIROLE_NS;
  962.   },
  963.   endPrefixMapping: function FP_endPrefixMapping(prefix) {
  964.     if (prefix)
  965.       delete this._waiPrefixes[prefix];
  966.   },
  967.   processingInstruction: function XH_processingInstruction() {
  968.   }, 
  969. }
  970.  
  971. /**
  972.  * The ExtensionHandler deals with elements we haven't explicitly
  973.  * added to our transition table in the FeedProcessor.
  974.  */
  975. function ExtensionHandler(processor) {
  976.   this._buf = "";
  977.   this._depth = 0;
  978.   this._hasChildElements = false;
  979.  
  980.   // The FeedProcessor
  981.   this._processor = processor;
  982.  
  983.   // Fields of the outermost extension element.
  984.   this._localName = null;
  985.   this._uri = null;
  986.   this._qName = null;
  987.   this._attrs = null;
  988. }
  989.  
  990. ExtensionHandler.prototype = {
  991.   startDocument: function EH_startDocument() {
  992.   },
  993.   endDocument: function EH_endDocument() {
  994.   },
  995.   startElement: function EH_startElement(uri, localName, qName, attrs) {
  996.     ++this._depth;
  997.     var prefix = gNamespaces[uri] ? gNamespaces[uri] + ":" : "";
  998.     var key =  prefix + localName;
  999.     
  1000.     if (this._depth == 1) {
  1001.       this._uri = uri;
  1002.       this._localName = localName;
  1003.       this._qName = qName;
  1004.       this._attrs = attrs;
  1005.     }
  1006.     
  1007.     // if we descend into another element, we won't send text
  1008.     this._hasChildElements = (this._depth > 1);
  1009.     
  1010.   },
  1011.   endElement: function EH_endElement(uri, localName, qName) {
  1012.     --this._depth;
  1013.     if (this._depth == 0) {
  1014.       var text = this._hasChildElements ? null : trimString(this._buf);
  1015.       this._processor.returnFromExtHandler(this._uri, this._localName, 
  1016.                                            text, this._attrs);
  1017.     }
  1018.   },
  1019.   characters: function EH_characters(data) {
  1020.     if (!this._hasChildElements)
  1021.       this._buf += data;
  1022.   },
  1023.   startPrefixMapping: function EH_startPrefixMapping() {
  1024.   },
  1025.   endPrefixMapping: function EH_endPrefixMapping() {
  1026.   },
  1027.   processingInstruction: function EH_processingInstruction() {
  1028.   }, 
  1029. };
  1030.  
  1031.  
  1032. /**
  1033.  * ElementInfo is a simple container object that describes
  1034.  * some characteristics of a feed element. For example, it
  1035.  * says whether an element can be expected to appear more
  1036.  * than once inside a given entry or feed.
  1037.  */ 
  1038. function ElementInfo(fieldName, containerClass, closeFunc, isArray) {
  1039.   this.fieldName = fieldName;
  1040.   this.containerClass = containerClass;
  1041.   this.closeFunc = closeFunc;
  1042.   this.isArray = isArray;
  1043.   this.isWrapper = false;
  1044. }
  1045.  
  1046. /**
  1047.  * FeedElementInfo represents a feed element, usually the root.
  1048.  */
  1049. function FeedElementInfo(fieldName, feedVersion) {
  1050.   this.isWrapper = false;
  1051.   this.fieldName = fieldName;
  1052.   this.feedVersion = feedVersion;
  1053. }
  1054.  
  1055. /**
  1056.  * Some feed formats include vestigial wrapper elements that we don't
  1057.  * want to include in our object model, but we do need to keep track
  1058.  * of during parsing.
  1059.  */
  1060. function WrapperElementInfo(fieldName) {
  1061.   this.isWrapper = true;
  1062.   this.fieldName = fieldName;
  1063. }
  1064.  
  1065. /***** The Processor *****/
  1066. function FeedProcessor() {
  1067.   this._reader = Cc[SAX_CONTRACTID].createInstance(Ci.nsISAXXMLReader);
  1068.   this._buf =  "";
  1069.   this._feed = Cc[BAG_CONTRACTID].createInstance(Ci.nsIWritablePropertyBag2);
  1070.   this._handlerStack = [];
  1071.   this._xmlBaseStack = []; // sparse array keyed to nesting depth
  1072.   this._depth = 0;
  1073.   this._state = "START";
  1074.   this._result = null;
  1075.   this._extensionHandler = null;
  1076.   this._xhtmlHandler = null;
  1077.   
  1078.   // http://www.w3.org/WAI/PF/GUI/ uses QNames in content :(
  1079.   this._waiPrefixes = {};
  1080.  
  1081.   // The nsIFeedResultListener waiting for the parse results
  1082.   this.listener = null;
  1083.  
  1084.   // These elements can contain (X)HTML or plain text.
  1085.   // We keep a table here that contains their default treatment
  1086.   this._textConstructs = {"atom:title":"text",
  1087.                           "atom:summary":"text",
  1088.                           "atom:rights":"text",
  1089.                           "atom:content":"text",
  1090.                           "atom:subtitle":"text",
  1091.                           "description":"html",
  1092.                           "rss1:description":"html",
  1093.                           "dc:description":"html",
  1094.                           "content:encoded":"html",
  1095.                           "title":"text",
  1096.                           "rss1:title":"text",
  1097.                           "atom03:title":"text",
  1098.                           "atom03:tagline":"text",
  1099.                           "atom03:summary":"text",
  1100.                           "atom03:content":"text"};
  1101.   this._stack = [];
  1102.  
  1103.   this._trans = {   
  1104.     "START": {
  1105.       //If we hit a root RSS element, treat as RSS2.
  1106.       "rss": new FeedElementInfo("RSS2", "rss2"),
  1107.  
  1108.       // If we hit an RDF element, if could be RSS1, but we can't
  1109.       // verify that until we hit a rss1:channel element.
  1110.       "rdf:RDF": new WrapperElementInfo("RDF"),
  1111.  
  1112.       // If we hit a Atom 1.0 element, treat as Atom 1.0.
  1113.       "atom:feed": new FeedElementInfo("Atom", "atom"),
  1114.  
  1115.       // Treat as Atom 0.3
  1116.       "atom03:feed": new FeedElementInfo("Atom03", "atom03"),
  1117.     },
  1118.     
  1119.     /********* RSS2 **********/
  1120.     "IN_RSS2": {
  1121.       "channel": new WrapperElementInfo("channel")
  1122.     },
  1123.  
  1124.     "IN_CHANNEL": {
  1125.       "item": new ElementInfo("items", Cc[ENTRY_CONTRACTID], null, true),
  1126.       "managingEditor": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1127.                                         rssAuthor, true),
  1128.       "dc:creator": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1129.                                     rssAuthor, true),
  1130.       "dc:author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1131.                                    rssAuthor, true),
  1132.       "dc:contributor": new ElementInfo("contributors", Cc[PERSON_CONTRACTID],
  1133.                                          rssAuthor, true),
  1134.       "category": new ElementInfo("categories", null, rssCatTerm, true),
  1135.       "cloud": new ElementInfo("cloud", null, null, false),
  1136.       "image": new ElementInfo("image", null, null, false),
  1137.       "textInput": new ElementInfo("textInput", null, null, false),
  1138.       "skipDays": new ElementInfo("skipDays", null, null, false),
  1139.       "skipHours": new ElementInfo("skipHours", null, null, false),
  1140.       "generator": new ElementInfo("generator", Cc[GENERATOR_CONTRACTID],
  1141.                                    atomGenerator, false),
  1142.     },
  1143.  
  1144.     "IN_ITEMS": {
  1145.       "author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1146.                                 rssAuthor, true),
  1147.       "dc:creator": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1148.                                     rssAuthor, true),
  1149.       "dc:author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1150.                                    rssAuthor, true),
  1151.       "dc:contributor": new ElementInfo("contributors", Cc[PERSON_CONTRACTID],
  1152.                                          rssAuthor, true),
  1153.       "category": new ElementInfo("categories", null, rssCatTerm, true),
  1154.       "enclosure": new ElementInfo("enclosure", null, null, true),
  1155.       "guid": new ElementInfo("guid", null, rssGuid, false)
  1156.     },
  1157.  
  1158.     "IN_SKIPDAYS": {
  1159.       "day": new ElementInfo("days", null, rssArrayElement, true)
  1160.     },
  1161.  
  1162.     "IN_SKIPHOURS":{
  1163.       "hour": new ElementInfo("hours", null, rssArrayElement, true)
  1164.     },
  1165.  
  1166.     /********* RSS1 **********/
  1167.     "IN_RDF": {
  1168.       // If we hit a rss1:channel, we can verify that we have RSS1
  1169.       "rss1:channel": new FeedElementInfo("rdf_channel", "rss1"),
  1170.       "rss1:image": new ElementInfo("image", null, null, false),
  1171.       "rss1:textinput": new ElementInfo("textInput", null, null, false),
  1172.       "rss1:item": new ElementInfo("items", Cc[ENTRY_CONTRACTID], null, true),
  1173.     },
  1174.  
  1175.     "IN_RDF_CHANNEL": {
  1176.       "admin:generatorAgent": new ElementInfo("generator",
  1177.                                               Cc[GENERATOR_CONTRACTID],
  1178.                                               null, false),
  1179.       "dc:creator": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1180.                                     rssAuthor, true),
  1181.       "dc:author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1182.                                    rssAuthor, true),
  1183.       "dc:contributor": new ElementInfo("contributors", Cc[PERSON_CONTRACTID],
  1184.                                          rssAuthor, true),
  1185.     },
  1186.  
  1187.     /********* ATOM 1.0 **********/
  1188.     "IN_ATOM": {
  1189.       "atom:author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1190.                                      null, true),
  1191.       "atom:generator": new ElementInfo("generator", Cc[GENERATOR_CONTRACTID],
  1192.                                         atomGenerator, false),
  1193.       "atom:contributor": new ElementInfo("contributors",  Cc[PERSON_CONTRACTID],
  1194.                                           null, true),
  1195.       "atom:link": new ElementInfo("links", null, null, true),
  1196.       "atom:logo": new ElementInfo("atom:logo", null, atomLogo, false),
  1197.       "atom:entry": new ElementInfo("entries", Cc[ENTRY_CONTRACTID],
  1198.                                     null, true)
  1199.     },
  1200.  
  1201.     "IN_ENTRIES": {
  1202.       "atom:author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1203.                                      null, true),
  1204.       "atom:contributor": new ElementInfo("contributors", Cc[PERSON_CONTRACTID],
  1205.                                           null, true),
  1206.       "atom:link": new ElementInfo("links", null, null, true),
  1207.     },
  1208.  
  1209.     /********* ATOM 0.3 **********/
  1210.     "IN_ATOM03": {
  1211.       "atom03:author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1212.                                        null, true),
  1213.       "atom03:contributor": new ElementInfo("contributors",
  1214.                                             Cc[PERSON_CONTRACTID],
  1215.                                             null, true),
  1216.       "atom03:link": new ElementInfo("links", null, null, true),
  1217.       "atom03:entry": new ElementInfo("atom03_entries", Cc[ENTRY_CONTRACTID],
  1218.                                       null, true),
  1219.       "atom03:generator": new ElementInfo("generator", Cc[GENERATOR_CONTRACTID],
  1220.                                           atomGenerator, false),
  1221.     },
  1222.  
  1223.     "IN_ATOM03_ENTRIES": {
  1224.       "atom03:author": new ElementInfo("authors", Cc[PERSON_CONTRACTID],
  1225.                                        null, true),
  1226.       "atom03:contributor": new ElementInfo("contributors",
  1227.                                             Cc[PERSON_CONTRACTID],
  1228.                                             null, true),
  1229.       "atom03:link": new ElementInfo("links", null, null, true),
  1230.       "atom03:entry": new ElementInfo("atom03_entries", Cc[ENTRY_CONTRACTID],
  1231.                                       null, true)
  1232.     }
  1233.   }
  1234. }
  1235.  
  1236. // See startElement for a long description of how feeds are processed.
  1237. FeedProcessor.prototype = { 
  1238.   
  1239.   // Set ourselves as the SAX handler, and set the base URI
  1240.   _init: function FP_init(uri) {
  1241.     this._reader.contentHandler = this;
  1242.     this._reader.errorHandler = this;
  1243.     this._result = Cc[FR_CONTRACTID].createInstance(Ci.nsIFeedResult);
  1244.     if (uri) {
  1245.       this._result.uri = uri;
  1246.       this._reader.baseURI = uri;
  1247.       this._xmlBaseStack[0] = uri;
  1248.     }
  1249.   },
  1250.  
  1251.   // This function is called once we figure out what type of feed
  1252.   // we're dealing with. Some feed types require digging a bit further
  1253.   // than the root.
  1254.   _docVerified: function FP_docVerified(version) {
  1255.     this._result.doc = Cc[FEED_CONTRACTID].createInstance(Ci.nsIFeed);
  1256.     this._result.doc.baseURI = 
  1257.       this._xmlBaseStack[this._xmlBaseStack.length - 1];
  1258.     this._result.doc.fields = this._feed;
  1259.     this._result.version = version;
  1260.   },
  1261.  
  1262.   // When we're done with the feed, let the listener know what
  1263.   // happened.
  1264.   _sendResult: function FP_sendResult() {
  1265.     try {
  1266.       // Can be null when a non-feed is fed to us
  1267.       if (this._result.doc)
  1268.         this._result.doc.normalize();
  1269.     }
  1270.     catch (e) {
  1271.       LOG("FIXME: " + e);
  1272.     }
  1273.  
  1274.     try {
  1275.       if (this.listener != null)
  1276.         this.listener.handleResult(this._result);
  1277.     }
  1278.     finally {
  1279.       this._result = null;
  1280.     }
  1281.   },
  1282.  
  1283.   // Parsing functions
  1284.   parseFromStream: function FP_parseFromStream(stream, uri) {
  1285.     this._init(uri);
  1286.     this._reader.parseFromStream(stream, null, stream.available(), 
  1287.                                  "application/xml");
  1288.     this._reader = null;
  1289.   },
  1290.  
  1291.   parseFromString: function FP_parseFromString(inputString, uri) {
  1292.     this._init(uri);
  1293.     this._reader.parseFromString(inputString, "application/xml");
  1294.     this._reader = null;
  1295.   },
  1296.  
  1297.   parseAsync: function FP_parseAsync(requestObserver, uri) {
  1298.     this._init(uri);
  1299.     this._reader.parseAsync(requestObserver);
  1300.   },
  1301.  
  1302.   // nsIStreamListener 
  1303.  
  1304.   // The XMLReader will throw sensible exceptions if these get called
  1305.   // out of order.
  1306.   onStartRequest: function FP_onStartRequest(request, context) {
  1307.     this._reader.onStartRequest(request, context);
  1308.   },
  1309.  
  1310.   onStopRequest: function FP_onStopRequest(request, context, statusCode) {
  1311.     try {
  1312.       this._reader.onStopRequest(request, context, statusCode);
  1313.     }
  1314.     finally {
  1315.       this._reader = null;
  1316.     }
  1317.   },
  1318.  
  1319.   onDataAvailable:
  1320.   function FP_onDataAvailable(request, context, inputStream, offset, count) {
  1321.     this._reader.onDataAvailable(request, context, inputStream, offset, count);
  1322.   },
  1323.  
  1324.   // nsISAXErrorHandler
  1325.  
  1326.   // We only care about fatal errors. When this happens, we may have
  1327.   // parsed through the feed metadata and some number of entries. The
  1328.   // listener can still show some of that data if it wants, and we'll
  1329.   // set the bozo bit to indicate we were unable to parse all the way
  1330.   // through.
  1331.   fatalError: function FP_reportError() {
  1332.     this._result.bozo = true;
  1333.     //XXX need to QI to FeedProgressListener
  1334.     this._sendResult();
  1335.   },
  1336.  
  1337.   // nsISAXContentHandler
  1338.  
  1339.   startDocument: function FP_startDocument() {
  1340.     //LOG("----------");
  1341.   },
  1342.  
  1343.   endDocument: function FP_endDocument() {
  1344.     this._sendResult();
  1345.   },
  1346.  
  1347.   // The transitions defined above identify elements that contain more
  1348.   // than just text. For example RSS items contain many fields, and so
  1349.   // do Atom authors. The only commonly used elements that contain
  1350.   // mixed content are Atom Text Constructs of type="xhtml", which we
  1351.   // delegate to another handler for cleaning. That leaves a couple
  1352.   // different types of elements to deal with: those that should occur
  1353.   // only once, such as title elements, and those that can occur
  1354.   // multiple times, such as the RSS category element and the Atom
  1355.   // link element. Most of the RSS1/DC elements can occur multiple
  1356.   // times in theory, but in practice, the only ones that do have
  1357.   // analogues in Atom. 
  1358.   //
  1359.   // Some elements are also groups of attributes or sub-elements,
  1360.   // while others are simple text fields. For the most part, we don't
  1361.   // have to pay explicit attention to the simple text elements,
  1362.   // unless we want to post-process the resulting string to transform
  1363.   // it into some richer object like a Date or URI.
  1364.   //
  1365.   // Elements that have more sophisticated content models still end up
  1366.   // being dictionaries, whether they are based on attributes like RSS
  1367.   // cloud, sub-elements like Atom author, or even items and
  1368.   // entries. These elements are treated as "containers". It's
  1369.   // theoretically possible for a container to have an attribute with 
  1370.   // the same universal name as a sub-element, but none of the feed
  1371.   // formats allow this by default, and I don't of any extension that
  1372.   // works this way.
  1373.   //
  1374.   startElement: function FP_startElement(uri, localName, qName, attributes) {
  1375.     this._buf = "";
  1376.     ++this._depth;
  1377.     var elementInfo;
  1378.  
  1379.     //LOG("<" + localName + ">");
  1380.  
  1381.     // Check for xml:base
  1382.     var base = attributes.getValueFromName(XMLNS, "base");
  1383.     if (base) {
  1384.       this._xmlBaseStack[this._depth] =
  1385.         strToURI(base, this._xmlBaseStack[this._xmlBaseStack.length - 1]);
  1386.     }
  1387.  
  1388.     // To identify the element we're dealing with, we look up the
  1389.     // namespace URI in our gNamespaces dictionary, which will give us
  1390.     // a "canonical" prefix for a namespace URI. For example, this
  1391.     // allows Dublin Core "creator" elements to be consistently mapped
  1392.     // to "dc:creator", for easy field access by consumer code. This
  1393.     // strategy also happens to shorten up our state table.
  1394.     var key =  this._prefixForNS(uri) + localName;
  1395.  
  1396.     // Check to see if we need to hand this off to our XHTML handler.
  1397.     // The elements we're dealing with will look like this:
  1398.     // 
  1399.     // <title type="xhtml">
  1400.     //   <div xmlns="http://www.w3.org/1999/xhtml">
  1401.     //     A title with <b>bold</b> and <i>italics</i>.
  1402.     //   </div>
  1403.     // </title>
  1404.     //
  1405.     // When it returns in returnFromXHTMLHandler, the handler should
  1406.     // give us back a string like this: 
  1407.     // 
  1408.     //    "A title with <b>bold</b> and <i>italics</i>."
  1409.     //
  1410.     // The Atom spec explicitly says the div is not part of the content,
  1411.     // and explicitly allows whitespace collapsing.
  1412.     // 
  1413.     if ((this._result.version == "atom" || this._result.version == "atom03") &&
  1414.         this._textConstructs[key] != null) {
  1415.       var type = attributes.getValueFromName("","type");
  1416.       if (type != null && type.indexOf("xhtml") >= 0) {
  1417.         this._xhtmlHandler = 
  1418.           new XHTMLHandler(this, (this._result.version == "atom"), 
  1419.                            this._waiPrefixes);
  1420.         this._reader.contentHandler = this._xhtmlHandler;
  1421.         return;
  1422.       }
  1423.     }
  1424.  
  1425.     // Check our current state, and see if that state has a defined
  1426.     // transition. For example, this._trans["atom:entry"]["atom:author"]
  1427.     // will have one, and it tells us to add an item to our authors array.
  1428.     if (this._trans[this._state] && this._trans[this._state][key]) {
  1429.       elementInfo = this._trans[this._state][key];
  1430.     }
  1431.     else {
  1432.       // If we don't have a transition, hand off to extension handler
  1433.       this._extensionHandler = new ExtensionHandler(this);
  1434.       this._reader.contentHandler = this._extensionHandler;
  1435.       this._extensionHandler.startElement(uri, localName, qName, attributes);
  1436.       return;
  1437.     }
  1438.       
  1439.     // This distinguishes wrappers like 'channel' from elements
  1440.     // we'd actually like to do something with (which will test true).
  1441.     this._handlerStack[this._depth] = elementInfo; 
  1442.     if (elementInfo.isWrapper) {
  1443.       this._state = "IN_" + elementInfo.fieldName.toUpperCase();
  1444.       this._stack.push([this._feed, this._state]);
  1445.     } 
  1446.     else if (elementInfo.feedVersion) {
  1447.       this._state = "IN_" + elementInfo.fieldName.toUpperCase();
  1448.  
  1449.       // Check for the older RSS2 variants
  1450.       if (elementInfo.feedVersion == "rss2")
  1451.         elementInfo.feedVersion = this._findRSSVersion(attributes);
  1452.       else if (uri == RSS090NS)
  1453.         elementInfo.feedVersion = "rss090";
  1454.  
  1455.       this._docVerified(elementInfo.feedVersion);
  1456.       this._stack.push([this._feed, this._state]);
  1457.       this._mapAttributes(this._feed, attributes);
  1458.     }
  1459.     else {
  1460.       this._state = this._processComplexElement(elementInfo, attributes);
  1461.     }
  1462.   },
  1463.  
  1464.   // In the endElement handler, we decrement the stack and look
  1465.   // for cleanup/transition functions to execute. The second part
  1466.   // of the state transition works as above in startElement, but
  1467.   // the state we're looking for is prefixed with an underscore
  1468.   // to distinguish endElement events from startElement events.
  1469.   endElement:  function FP_endElement(uri, localName, qName) {
  1470.     var elementInfo = this._handlerStack[this._depth];
  1471.     //LOG("</" + localName + ">");
  1472.     if (elementInfo && !elementInfo.isWrapper)
  1473.       this._closeComplexElement(elementInfo);
  1474.   
  1475.     // cut down xml:base context
  1476.     if (this._xmlBaseStack.length == this._depth + 1)
  1477.       this._xmlBaseStack = this._xmlBaseStack.slice(0, this._depth);
  1478.  
  1479.     // our new state is whatever is at the top of the stack now
  1480.     if (this._stack.length > 0)
  1481.       this._state = this._stack[this._stack.length - 1][1];
  1482.     this._handlerStack = this._handlerStack.slice(0, this._depth);
  1483.     --this._depth;
  1484.   },
  1485.  
  1486.   // Buffer up character data. The buffer is cleared with every
  1487.   // opening element.
  1488.   characters: function FP_characters(data) {
  1489.     this._buf += data;
  1490.   },
  1491.   // TODO: It would be nice to check new prefixes here, and if they
  1492.   // don't conflict with the ones we've defined, throw them in a 
  1493.   // dictionary to check.
  1494.   startPrefixMapping: function FP_startPrefixMapping(prefix, uri) {
  1495.     // Thanks for QNames in content, W3C
  1496.     // This will even be a perf hit for every single feed
  1497.     // http://www.w3.org/WAI/PF/GUI/
  1498.     if (prefix && uri == WAIROLE_NS) 
  1499.       this._waiPrefixes[prefix] = WAIROLE_NS;
  1500.   },
  1501.   
  1502.   endPrefixMapping: function FP_endPrefixMapping(prefix) {
  1503.     if (prefix)
  1504.       delete this._waiPrefixes[prefix];
  1505.   },
  1506.   
  1507.   processingInstruction: function FP_processingInstruction(target, data) {
  1508.     if (target == "xml-stylesheet") {
  1509.       var hrefAttribute = data.match(/href=[\"\'](.*?)[\"\']/);
  1510.       if (hrefAttribute && hrefAttribute.length == 2) 
  1511.         this._result.stylesheet = gIoService.newURI(hrefAttribute[1], null,
  1512.                                                     this._result.uri);
  1513.     }
  1514.   },
  1515.  
  1516.   // end of nsISAXContentHandler
  1517.  
  1518.   // Handle our more complicated elements--those that contain
  1519.   // attributes and child elements.
  1520.   _processComplexElement:
  1521.   function FP__processComplexElement(elementInfo, attributes) {
  1522.     var obj, key, prefix;
  1523.  
  1524.     // If the container is an entry/item, it'll need to have its 
  1525.     // more esoteric properties put in the 'fields' property bag.
  1526.     if (elementInfo.containerClass == Cc[ENTRY_CONTRACTID]) {
  1527.       obj = elementInfo.containerClass.createInstance(Ci.nsIFeedEntry);
  1528.       obj.baseURI = this._xmlBaseStack[this._xmlBaseStack.length - 1];
  1529.       this._mapAttributes(obj.fields, attributes);
  1530.     }
  1531.     else if (elementInfo.containerClass) {
  1532.       obj = elementInfo.containerClass.createInstance(Ci.nsIFeedElementBase);
  1533.       obj.baseURI = this._xmlBaseStack[this._xmlBaseStack.length - 1];
  1534.       obj.attributes = attributes; // just set the SAX attributes
  1535.     }
  1536.     else {
  1537.       obj = Cc[BAG_CONTRACTID].createInstance(Ci.nsIWritablePropertyBag2);
  1538.       this._mapAttributes(obj, attributes);
  1539.     }
  1540.  
  1541.     // We should have a container/propertyBag that's had its
  1542.     // attributes processed. Now we need to attach it to its
  1543.     // container.
  1544.     var newProp;
  1545.  
  1546.     // First we'll see what's on top of the stack.
  1547.     var container = this._stack[this._stack.length - 1][0];
  1548.  
  1549.     // Check to see if it has the property
  1550.     var prop;
  1551.     try {
  1552.       prop = container.getProperty(elementInfo.fieldName);
  1553.     }
  1554.     catch(e) {
  1555.     }
  1556.     
  1557.     if (elementInfo.isArray) {
  1558.       if (!prop) {
  1559.         container.setPropertyAsInterface(elementInfo.fieldName,
  1560.                                          Cc[ARRAY_CONTRACTID].
  1561.                                          createInstance(Ci.nsIMutableArray));
  1562.       }
  1563.  
  1564.       newProp = container.getProperty(elementInfo.fieldName);
  1565.       // XXX This QI should not be necessary, but XPConnect seems to fly
  1566.       // off the handle in the browser, and loses track of the interface
  1567.       // on large files. Bug 335638.
  1568.       newProp.QueryInterface(Ci.nsIMutableArray);
  1569.       newProp.appendElement(obj,false);
  1570.       
  1571.       // If new object is an nsIFeedContainer, we want to deal with
  1572.       // its member nsIPropertyBag instead.
  1573.       if (isIFeedContainer(obj))
  1574.         newProp = obj.fields; 
  1575.  
  1576.     }
  1577.     else {
  1578.       // If it doesn't, set it.
  1579.       if (!prop) {
  1580.         container.setPropertyAsInterface(elementInfo.fieldName,obj);
  1581.       }
  1582.       newProp = container.getProperty(elementInfo.fieldName);
  1583.     }
  1584.     
  1585.     // make our new state name, and push the property onto the stack
  1586.     var newState = "IN_" + elementInfo.fieldName.toUpperCase();
  1587.     this._stack.push([newProp, newState, obj]);
  1588.     return newState;
  1589.   },
  1590.  
  1591.   // Sometimes we need reconcile the element content with the object
  1592.   // model for a given feed. We use helper functions to do the
  1593.   // munging, but we need to identify array types here, so the munging
  1594.   // happens only to the last element of an array.
  1595.   _closeComplexElement: function FP__closeComplexElement(elementInfo) {
  1596.     var stateTuple = this._stack.pop();
  1597.     var container = stateTuple[0];
  1598.     var containerParent = stateTuple[2];
  1599.     var element = null;
  1600.     var isArray = isIArray(container);
  1601.  
  1602.     // If it's an array and we have to post-process,
  1603.     // grab the last element
  1604.     if (isArray)
  1605.       element = container.queryElementAt(container.length - 1, Ci.nsISupports);
  1606.     else
  1607.       element = container;
  1608.  
  1609.     // Run the post-processing function if there is one.
  1610.     if (elementInfo.closeFunc)
  1611.       element = elementInfo.closeFunc(this._buf, element);
  1612.  
  1613.     // If an nsIFeedContainer was on top of the stack,
  1614.     // we need to normalize it
  1615.     if (elementInfo.containerClass == Cc[ENTRY_CONTRACTID])
  1616.       containerParent.normalize();
  1617.  
  1618.     // If it's an array, re-set the last element
  1619.     if (isArray)
  1620.       container.replaceElementAt(element, container.length - 1, false);
  1621.   },
  1622.   
  1623.   _prefixForNS: function FP_prefixForNS(uri) {
  1624.     if (!uri)
  1625.       return "";
  1626.     var prefix = gNamespaces[uri];
  1627.     if (prefix)
  1628.       return prefix + ":";
  1629.     if (uri.toLowerCase().indexOf("http://backend.userland.com") == 0)
  1630.       return "";
  1631.     else
  1632.       return null;
  1633.   },
  1634.  
  1635.   _mapAttributes: function FP__mapAttributes(bag, attributes) {
  1636.     // Cycle through the attributes, and set our properties using the
  1637.     // prefix:localNames we find in our namespace dictionary.
  1638.     for (var i = 0; i < attributes.length; ++i) {
  1639.       var key = this._prefixForNS(attributes.getURI(i)) + attributes.getLocalName(i);
  1640.       var val = attributes.getValue(i);
  1641.       bag.setPropertyAsAString(key, val);
  1642.     }
  1643.   },
  1644.  
  1645.   // Only for RSS2esque formats
  1646.   _findRSSVersion: function FP__findRSSVersion(attributes) {
  1647.     var versionAttr = trimString(attributes.getValueFromName("", "version"));
  1648.     var versions = { "0.91":"rss091",
  1649.                      "0.92":"rss092",
  1650.                      "0.93":"rss093",
  1651.                      "0.94":"rss094" }
  1652.     if (versions[versionAttr])
  1653.       return versions[versionAttr];
  1654.     if (versionAttr.substr(0,2) != "2.")
  1655.       return "rssUnknown";
  1656.     return "rss2";
  1657.   },
  1658.  
  1659.   // unknown element values are returned here. See startElement above
  1660.   // for how this works.
  1661.   returnFromExtHandler:
  1662.   function FP_returnExt(uri, localName, chars, attributes) {
  1663.     --this._depth;
  1664.  
  1665.     // take control of the SAX events
  1666.     this._reader.contentHandler = this;
  1667.     if (localName == null && chars == null)
  1668.       return;
  1669.  
  1670.     // we don't take random elements inside rdf:RDF
  1671.     if (this._state == "IN_RDF")
  1672.       return;
  1673.     
  1674.     // Grab the top of the stack
  1675.     var top = this._stack[this._stack.length - 1];
  1676.     if (!top) 
  1677.       return;
  1678.  
  1679.     var container = top[0];
  1680.     // Grab the last element if it's an array
  1681.     if (isIArray(container)) {
  1682.       var contract = this._handlerStack[this._depth].containerClass;
  1683.       // check if it's something specific, but not an entry
  1684.       if (contract && contract != Cc[ENTRY_CONTRACTID]) {
  1685.         var el = container.queryElementAt(container.length - 1, 
  1686.                                           Ci.nsIFeedElementBase);
  1687.         // XXX there must be a way to flatten these interfaces
  1688.         if (contract == Cc[PERSON_CONTRACTID]) 
  1689.           el.QueryInterface(Ci.nsIFeedPerson);
  1690.         else
  1691.           return; // don't know about this interface
  1692.  
  1693.         var propName = localName;
  1694.         var prefix = gNamespaces[uri];
  1695.  
  1696.         // synonyms
  1697.         if ((uri == "" || 
  1698.              prefix &&
  1699.              ((prefix.indexOf("atom") > -1) ||
  1700.               (prefix.indexOf("rss") > -1))) && 
  1701.             (propName == "url" || propName == "href"))
  1702.           propName = "uri";
  1703.         
  1704.         try {
  1705.           if (el[propName] !== "undefined") {
  1706.             var propValue = chars;
  1707.             // convert URI-bearing values to an nsIURI
  1708.             if (propName == "uri") {
  1709.               var base = this._xmlBaseStack[this._xmlBaseStack.length - 1];
  1710.               propValue = strToURI(chars, base);
  1711.             }
  1712.             el[propName] = propValue;
  1713.           }
  1714.         }
  1715.         catch(e) {
  1716.           // ignore XPConnect errors
  1717.         }
  1718.         // the rest of the function deals with entry- and feed-level stuff
  1719.         return; 
  1720.       } 
  1721.       else {
  1722.         container = container.queryElementAt(container.length - 1, 
  1723.                                              Ci.nsIWritablePropertyBag2);
  1724.       }
  1725.     }
  1726.     
  1727.     // Make the buffer our new property
  1728.     var propName = this._prefixForNS(uri) + localName;
  1729.  
  1730.     // But, it could be something containing HTML. If so,
  1731.     // we need to know about that.
  1732.     if (this._textConstructs[propName] != null &&
  1733.         this._handlerStack[this._depth].containerClass !== null) {
  1734.       var newProp = Cc[TEXTCONSTRUCT_CONTRACTID].
  1735.                     createInstance(Ci.nsIFeedTextConstruct);
  1736.       newProp.text = chars;
  1737.       // Look up the default type in our table
  1738.       var type = this._textConstructs[propName];
  1739.       var typeAttribute = attributes.getValueFromName("","type");
  1740.       if (this._result.version == "atom" && typeAttribute != null) {
  1741.         type = typeAttribute;
  1742.       }
  1743.       else if (this._result.version == "atom03" && typeAttribute != null) {
  1744.         if (typeAttribute.toLowerCase().indexOf("xhtml") >= 0) {
  1745.           type = "xhtml";
  1746.         }
  1747.         else if (typeAttribute.toLowerCase().indexOf("html") >= 0) {
  1748.           type = "html";
  1749.         }
  1750.         else if (typeAttribute.toLowerCase().indexOf("text") >= 0) {
  1751.           type = "text";
  1752.         }
  1753.       }
  1754.       
  1755.       // If it's rss feed-level description, it's not supposed to have html
  1756.       if (this._result.version.indexOf("rss") >= 0 &&
  1757.           this._handlerStack[this._depth].containerClass != ENTRY_CONTRACTID) {
  1758.         type = "text";
  1759.       }
  1760.       newProp.type = type;
  1761.       newProp.base = this._xmlBaseStack[this._xmlBaseStack.length - 1];
  1762.       container.setPropertyAsInterface(propName, newProp);
  1763.     }
  1764.     else {
  1765.       container.setPropertyAsAString(propName, chars);
  1766.     }
  1767.   },
  1768.  
  1769.   // Sometimes, we'll hand off SAX handling duties to an XHTMLHandler
  1770.   // (see above) that will scrape out non-XHTML stuff, normalize
  1771.   // namespaces, and remove the wrapper div from Atom 1.0. When the
  1772.   // XHTMLHandler is done, it'll callback here.
  1773.   returnFromXHTMLHandler:
  1774.   function FP_returnFromXHTMLHandler(chars, uri, localName, qName) {
  1775.     // retake control of the SAX content events
  1776.     this._reader.contentHandler = this;
  1777.  
  1778.     // Grab the top of the stack
  1779.     var top = this._stack[this._stack.length - 1];
  1780.     if (!top) 
  1781.       return;
  1782.     var container = top[0];
  1783.  
  1784.     // Assign the property
  1785.     var newProp =  newProp = Cc[TEXTCONSTRUCT_CONTRACTID].
  1786.                    createInstance(Ci.nsIFeedTextConstruct);
  1787.     newProp.text = chars;
  1788.     newProp.type = "xhtml";
  1789.     newProp.base = this._xmlBaseStack[this._xmlBaseStack.length - 1];
  1790.     container.setPropertyAsInterface(this._prefixForNS(uri) + localName,
  1791.                                      newProp);
  1792.     
  1793.     // XHTML will cause us to peek too far. The XHTML handler will
  1794.     // send us an end element to call. RFC4287-valid feeds allow a
  1795.     // more graceful way to handle this. Unfortunately, we can't count
  1796.     // on compliance at this point.
  1797.     this.endElement(uri, localName, qName);
  1798.   },
  1799.  
  1800.   // XPCOM stuff
  1801.   classDescription: FP_CLASSNAME,
  1802.   classID: FP_CLASSID,
  1803.   contractID: FP_CONTRACTID,
  1804.   QueryInterface: XPCOMUtils.generateQI(
  1805.     [Ci.nsIFeedProcessor, Ci.nsISAXContentHandler, Ci.nsISAXErrorHandler,
  1806.      Ci.nsIStreamListener, Ci.nsIRequestObserver]
  1807.   )
  1808. }
  1809.  
  1810. var components = [FeedProcessor, FeedResult, Feed, Entry,
  1811.                   TextConstruct, Generator, Person];
  1812. function NSGetModule(compMgr, fileSpec) {
  1813.   return XPCOMUtils.generateModule(components);
  1814.   
  1815. }
  1816.